﻿using System;
using System.Collections.Generic;
using IllusionUtility.GetUtility;
using RootMotion.FinalIK;
using UnityEngine;
using Utility;

// Token: 0x02000248 RID: 584
public class AnimeIKCtrl : MonoBehaviour
{
	// Token: 0x170001AD RID: 429
	// (get) Token: 0x06000D32 RID: 3378 RVA: 0x0005DD48 File Offset: 0x0005BF48
	// (set) Token: 0x06000D33 RID: 3379 RVA: 0x0005DD50 File Offset: 0x0005BF50
	public float[] _editRate { get; set; }

	// Token: 0x170001AE RID: 430
	// (get) Token: 0x06000D34 RID: 3380 RVA: 0x0005DD5C File Offset: 0x0005BF5C
	// (set) Token: 0x06000D35 RID: 3381 RVA: 0x0005DD64 File Offset: 0x0005BF64
	public global::CharCustom _editInfo { get; set; }

	// Token: 0x170001AF RID: 431
	// (get) Token: 0x06000D36 RID: 3382 RVA: 0x0005DD70 File Offset: 0x0005BF70
	// (set) Token: 0x06000D37 RID: 3383 RVA: 0x0005DD78 File Offset: 0x0005BF78
	public global::CharCustom _editInfoAnother { get; set; }

	// Token: 0x170001B0 RID: 432
	// (get) Token: 0x06000D38 RID: 3384 RVA: 0x0005DD84 File Offset: 0x0005BF84
	// (set) Token: 0x06000D39 RID: 3385 RVA: 0x0005DD8C File Offset: 0x0005BF8C
	public global::CharCustom _editInfoAnother1 { get; set; }

	// Token: 0x170001B1 RID: 433
	// (get) Token: 0x06000D3A RID: 3386 RVA: 0x0005DD98 File Offset: 0x0005BF98
	// (set) Token: 0x06000D3B RID: 3387 RVA: 0x0005DDA0 File Offset: 0x0005BFA0
	public GameObject _partnerObj { get; set; }

	// Token: 0x170001B2 RID: 434
	// (get) Token: 0x06000D3C RID: 3388 RVA: 0x0005DDAC File Offset: 0x0005BFAC
	// (set) Token: 0x06000D3D RID: 3389 RVA: 0x0005DDB4 File Offset: 0x0005BFB4
	public GameObject _partnerObj1 { get; set; }

	// Token: 0x170001B3 RID: 435
	// (get) Token: 0x06000D3E RID: 3390 RVA: 0x0005DDC0 File Offset: 0x0005BFC0
	// (set) Token: 0x06000D3F RID: 3391 RVA: 0x0005DDC8 File Offset: 0x0005BFC8
	public GameObject _itemObj { get; set; }

	// Token: 0x170001B4 RID: 436
	// (get) Token: 0x06000D40 RID: 3392 RVA: 0x0005DDD4 File Offset: 0x0005BFD4
	// (set) Token: 0x06000D41 RID: 3393 RVA: 0x0005DDDC File Offset: 0x0005BFDC
	public FullBodyBipedIK IK
	{
		get
		{
			return this._ik;
		}
		set
		{
			this._ik = value;
		}
	}

	// Token: 0x170001B5 RID: 437
	// (get) Token: 0x06000D42 RID: 3394 RVA: 0x0005DDE8 File Offset: 0x0005BFE8
	public bool IsIKBlend
	{
		get
		{
			return this._isIKBlend;
		}
	}

	// Token: 0x170001B6 RID: 438
	// (get) Token: 0x06000D43 RID: 3395 RVA: 0x0005DDF0 File Offset: 0x0005BFF0
	// (set) Token: 0x06000D44 RID: 3396 RVA: 0x0005DDF8 File Offset: 0x0005BFF8
	public bool IsInit { get; private set; }

	// Token: 0x06000D45 RID: 3397 RVA: 0x0005DE04 File Offset: 0x0005C004
	public virtual void Start()
	{
		this.Init();
	}

	// Token: 0x06000D46 RID: 3398 RVA: 0x0005DE0C File Offset: 0x0005C00C
	public virtual void Init()
	{
		if (this.IsInit)
		{
			return;
		}
		this.IsInit = false;
		if (this._animator == null)
		{
			UnityEngine.Object.Destroy(this);
		}
		if (this._ik == null)
		{
			UnityEngine.Object.Destroy(this);
		}
		this._ikBlend = new global::AnimeIKCtrl.IKBlendInfo[9];
		this._ikTarget = new global::AnimeIKCtrl.IKTargetCorrection[9];
		int[] array = new int[]
		{
			2,
			2,
			1,
			2,
			1,
			2,
			1,
			2,
			1
		};
		for (int i = 0; i < 9; i++)
		{
			this._ikBlend[i] = new global::AnimeIKCtrl.IKBlendInfo();
			this._ikBlend[i]._fromWeight = new float[array[i]];
			this._ikBlend[i]._toWeight = new float[array[i]];
			this._ikBlend[i]._lerpTarget.transform.parent = base.transform;
			this._ikBlend[i]._lerpTarget.transform.name = this._ikBlend[i]._lerpTarget.transform.name + "_" + i;
			this._ikTarget[i] = new global::AnimeIKCtrl.IKTargetCorrection();
			this._ikTarget[i].Init();
		}
		this.IsInit = true;
	}

	// Token: 0x06000D47 RID: 3399 RVA: 0x0005DF50 File Offset: 0x0005C150
	public virtual void LateUpdate()
	{
		if (!this._ik.solver.initiated)
		{
			return;
		}
		this.UpdateAnimeIK();
		if (this._animator.runtimeAnimatorController == null)
		{
			return;
		}
		this._animeTransInfo = this._animator.GetAnimatorTransitionInfo(0);
		if (this._isIKBlend)
		{
			if (!this._ik.enabled)
			{
				this._isIKBlend = false;
			}
			else
			{
				global::AnimeIKCtrl.AnimeIKInfo.BlendType blendType = this._blendType;
				if (blendType != global::AnimeIKCtrl.AnimeIKInfo.BlendType.Type0)
				{
					if (blendType == global::AnimeIKCtrl.AnimeIKInfo.BlendType.Type1)
					{
						if (this._blendTime == 0f || Mathf.InverseLerp(0f, this._blendTime, this._time) >= 1f)
						{
							this.SetForceIK(this._ikInfoNext);
							this._ikInfoNext = null;
							this._isIKBlend = false;
						}
					}
				}
				else if (this._animeTransInfo.normalizedTime == 0f)
				{
					this.SetForceIK(this._ikInfoNext);
					this._ikInfoNext = null;
					this._isIKBlend = false;
				}
			}
		}
		this.UpdateIKTargetCorrection();
		float t = 0f;
		if (this._isIKBlend)
		{
			global::AnimeIKCtrl.AnimeIKInfo.BlendType blendType = this._blendType;
			if (blendType != global::AnimeIKCtrl.AnimeIKInfo.BlendType.Type0)
			{
				if (blendType == global::AnimeIKCtrl.AnimeIKInfo.BlendType.Type1)
				{
					this._time += Time.deltaTime;
					this._time = Mathf.Clamp(this._time + Time.deltaTime, 0f, this._blendTime);
					t = Mathf.InverseLerp(0f, this._blendTime, this._time);
				}
			}
			else
			{
				t = this._animeTransInfo.normalizedTime;
			}
		}
		foreach (global::AnimeIKCtrl.IKBlendInfo ikblendInfo in this._ikBlend)
		{
			switch (ikblendInfo._type)
			{
			case global::AnimeIKCtrl.IKBlendInfo.BlendType.Type0:
				if (ikblendInfo._effector != null)
				{
					ikblendInfo._effector.positionWeight = Mathf.Lerp(ikblendInfo._fromWeight[0], ikblendInfo._toWeight[0], t);
					ikblendInfo._effector.rotationWeight = Mathf.Lerp(ikblendInfo._fromWeight[1], ikblendInfo._toWeight[1], t);
				}
				else if (ikblendInfo._bend != null)
				{
					ikblendInfo._bend.weight = Mathf.Lerp(ikblendInfo._fromWeight[0], ikblendInfo._toWeight[0], t);
				}
				break;
			case global::AnimeIKCtrl.IKBlendInfo.BlendType.Type1:
			{
				Vector3[] array = new Vector3[]
				{
					Vector3.zero,
					Vector3.zero
				};
				Vector3[] array2 = new Vector3[]
				{
					Vector3.zero,
					Vector3.zero
				};
				Vector3[] array3 = new Vector3[]
				{
					Vector3.zero,
					Vector3.zero
				};
				for (int j = 0; j < 2; j++)
				{
					for (int k = 0; k < ikblendInfo._targetCorrection[j]._info.Count; k++)
					{
						float shapeValue = this.GetShapeValue(Mathf.Max(ikblendInfo._targetCorrection[j]._info[k]._editNo, 0));
						if (shapeValue >= 0.5f)
						{
							float t2 = Mathf.InverseLerp(0.5f, 1f, shapeValue);
							array3[j] = Vector3.Lerp(Vector3.zero, ikblendInfo._targetCorrection[j]._info[k]._tmax, t2);
						}
						else
						{
							float t3 = Mathf.InverseLerp(0f, 0.5f, shapeValue);
							array3[j] = Vector3.Lerp(ikblendInfo._targetCorrection[j]._info[k]._tmin, Vector3.zero, t3);
						}
						array[j] += ikblendInfo._targetCorrection[j].TargetBone.TransformDirection(array3[j]);
						if (shapeValue >= 0.5f)
						{
							float t4 = Mathf.InverseLerp(0.5f, 1f, shapeValue);
							array3[j] = Vector3.Lerp(Vector3.zero, ikblendInfo._targetCorrection[j]._info[k]._rmax, t4);
						}
						else
						{
							float t5 = Mathf.InverseLerp(0f, 0.5f, shapeValue);
							array3[j] = Vector3.Lerp(ikblendInfo._targetCorrection[j]._info[k]._rmin, Vector3.zero, t5);
						}
						array2[j] += array3[j];
					}
				}
				Vector3 a = ikblendInfo._fromTarget.position + array[0];
				Vector3 b = ikblendInfo._toTarget.position + array[1];
				ikblendInfo._lerpTarget.transform.position = Vector3.Lerp(a, b, t);
				Quaternion a2 = ((!(ikblendInfo._fromTarget.transform.parent != null)) ? Quaternion.identity : ikblendInfo._fromTarget.transform.parent.rotation) * Quaternion.Euler(ikblendInfo._fromTarget.transform.localRotation.eulerAngles + array2[0]);
				Quaternion b2 = ((!(ikblendInfo._toTarget.transform.parent != null)) ? Quaternion.identity : ikblendInfo._toTarget.transform.parent.rotation) * Quaternion.Euler(ikblendInfo._toTarget.transform.localRotation.eulerAngles + array2[1]);
				ikblendInfo._lerpTarget.transform.rotation = Quaternion.Slerp(a2, b2, t);
				if (ikblendInfo._effector != null)
				{
					ikblendInfo._effector.positionWeight = Mathf.Lerp(ikblendInfo._fromWeight[0], ikblendInfo._toWeight[0], t);
					ikblendInfo._effector.rotationWeight = Mathf.Lerp(ikblendInfo._fromWeight[1], ikblendInfo._toWeight[1], t);
				}
				else if (ikblendInfo._bend != null)
				{
					ikblendInfo._bend.bendGoal = ikblendInfo._lerpTarget.transform;
					ikblendInfo._bend.weight = Mathf.Lerp(ikblendInfo._fromWeight[0], ikblendInfo._toWeight[0], t);
				}
				break;
			}
			case global::AnimeIKCtrl.IKBlendInfo.BlendType.Type2:
				if (ikblendInfo._effector != null)
				{
					ikblendInfo._effector.positionWeight = Mathf.Lerp(ikblendInfo._fromWeight[0], ikblendInfo._toWeight[0], t);
					ikblendInfo._effector.rotationWeight = Mathf.Lerp(ikblendInfo._fromWeight[1], ikblendInfo._toWeight[1], t);
				}
				else if (ikblendInfo._bend != null)
				{
					ikblendInfo._bend.weight = Mathf.Lerp(ikblendInfo._fromWeight[0], ikblendInfo._toWeight[0], t);
				}
				break;
			}
		}
		if (this._ik != null && this._ik.isActiveAndEnabled)
		{
			this._ik.solver.Update();
		}
	}

	// Token: 0x06000D48 RID: 3400 RVA: 0x0005E6EC File Offset: 0x0005C8EC
	public virtual void Release()
	{
		this._ikList = null;
	}

	// Token: 0x06000D49 RID: 3401 RVA: 0x0005E6F8 File Offset: 0x0005C8F8
	public virtual void SetForceIK(global::AnimeIKCtrl.AnimeIKInfo animeInfo)
	{
		this._ikInfoOld = null;
		bool flag = false;
		flag |= this.SetIKInfo(0, -1, animeInfo._bodyIK, this._ik.solver.bodyEffector, null);
		flag |= this.SetIKInfo(1, 2, animeInfo._leftArmIK, this._ik.solver.leftHandEffector, this._ik.solver.leftArmChain.bendConstraint);
		flag |= this.SetIKInfo(3, 4, animeInfo._rightArmIK, this._ik.solver.rightHandEffector, this._ik.solver.rightArmChain.bendConstraint);
		flag |= this.SetIKInfo(5, 6, animeInfo._LeftLegIK, this._ik.solver.leftFootEffector, this._ik.solver.leftLegChain.bendConstraint);
		flag |= this.SetIKInfo(7, 8, animeInfo._rightLegIK, this._ik.solver.rightFootEffector, this._ik.solver.rightLegChain.bendConstraint);
		this._ik.enabled = flag;
		this._ikInfoOld = animeInfo;
		foreach (global::AnimeIKCtrl.IKBlendInfo ikblendInfo in this._ikBlend)
		{
			ikblendInfo._type = global::AnimeIKCtrl.IKBlendInfo.BlendType.Type3;
		}
		if (flag)
		{
			return;
		}
		this._ik.enabled = false;
	}

	// Token: 0x06000D4A RID: 3402 RVA: 0x0005E854 File Offset: 0x0005CA54
	public virtual void SetBlendIK(global::AnimeIKCtrl.AnimeIKInfo animeInfo, bool animeTrans = true)
	{
		bool flag = false;
		flag |= this.SetBlendInfo(0, -1, animeInfo._bodyIK, (this._ikInfoOld == null) ? null : this._ikInfoOld._bodyIK, this._ik.solver.bodyEffector, null);
		flag |= this.SetBlendInfo(1, 2, animeInfo._leftArmIK, (this._ikInfoOld == null) ? null : this._ikInfoOld._leftArmIK, this._ik.solver.leftHandEffector, this._ik.solver.leftArmChain.bendConstraint);
		flag |= this.SetBlendInfo(3, 4, animeInfo._rightArmIK, (this._ikInfoOld == null) ? null : this._ikInfoOld._rightArmIK, this._ik.solver.rightHandEffector, this._ik.solver.rightArmChain.bendConstraint);
		flag |= this.SetBlendInfo(5, 6, animeInfo._LeftLegIK, (this._ikInfoOld == null) ? null : this._ikInfoOld._LeftLegIK, this._ik.solver.leftFootEffector, this._ik.solver.leftLegChain.bendConstraint);
		flag |= this.SetBlendInfo(7, 8, animeInfo._rightLegIK, (this._ikInfoOld == null) ? null : this._ikInfoOld._rightLegIK, this._ik.solver.rightFootEffector, this._ik.solver.rightLegChain.bendConstraint);
		this._ik.enabled = flag;
		this._blendType = ((!animeTrans) ? global::AnimeIKCtrl.AnimeIKInfo.BlendType.Type1 : global::AnimeIKCtrl.AnimeIKInfo.BlendType.Type0);
		this._blendTime = animeInfo._blendTime;
		this._time = 0f;
		this._isIKBlend = true;
		if (flag)
		{
			this._ikInfoNext = animeInfo;
			return;
		}
		bool flag2 = false;
		flag2 |= this.SetBlendInfo(0, -1, null, (this._ikInfoOld == null) ? null : this._ikInfoOld._bodyIK, this._ik.solver.bodyEffector, null);
		flag2 |= this.SetBlendInfo(1, 2, null, (this._ikInfoOld == null) ? null : this._ikInfoOld._leftArmIK, this._ik.solver.leftHandEffector, this._ik.solver.leftArmChain.bendConstraint);
		flag2 |= this.SetBlendInfo(3, 4, null, (this._ikInfoOld == null) ? null : this._ikInfoOld._rightArmIK, this._ik.solver.rightHandEffector, this._ik.solver.rightArmChain.bendConstraint);
		flag2 |= this.SetBlendInfo(5, 6, null, (this._ikInfoOld == null) ? null : this._ikInfoOld._LeftLegIK, this._ik.solver.leftFootEffector, this._ik.solver.leftLegChain.bendConstraint);
		flag2 |= this.SetBlendInfo(7, 8, null, (this._ikInfoOld == null) ? null : this._ikInfoOld._rightLegIK, this._ik.solver.rightFootEffector, this._ik.solver.rightLegChain.bendConstraint);
		this._ik.enabled = flag2;
	}

	// Token: 0x06000D4B RID: 3403 RVA: 0x0005EBB0 File Offset: 0x0005CDB0
	public virtual void SetIK(string _name)
	{
		foreach (global::AnimeIKCtrl.AnimeIKInfo animeIKInfo in this._ikList)
		{
			if (string.Compare(animeIKInfo._animeName, _name) == 0)
			{
				this.SetBlendIK(animeIKInfo, false);
				break;
			}
		}
	}

	// Token: 0x06000D4C RID: 3404 RVA: 0x0005EC00 File Offset: 0x0005CE00
	public virtual void UpdateIKTargetCorrection()
	{
		int num = this._ikTarget.Length;
		for (int i = 0; i < num; i++)
		{
			global::AnimeIKCtrl.IKTargetCorrection iktargetCorrection = this._ikTarget[i];
			if (!(iktargetCorrection.TargetBone == null))
			{
				Vector3 vector = iktargetCorrection.TargetBone.position;
				Vector3 vector2 = iktargetCorrection.TargetBone.transform.localEulerAngles;
				for (int j = 0; j < iktargetCorrection._info.Count; j++)
				{
					float shapeValue = this.GetShapeValue(Mathf.Max(iktargetCorrection._info[j]._editNo, 0));
					Vector3 vector3 = (shapeValue < 0.5f) ? Vector3.Lerp(iktargetCorrection._info[j]._tmin, Vector3.zero, Mathf.InverseLerp(0f, 0.5f, shapeValue)) : Vector3.Lerp(Vector3.zero, iktargetCorrection._info[j]._tmax, Mathf.InverseLerp(0.5f, 1f, shapeValue));
					vector3 = iktargetCorrection.TargetBone.TransformDirection(vector3);
					vector += vector3;
					vector3 = ((shapeValue < 0.5f) ? Vector3.Lerp(iktargetCorrection._info[j]._rmin, Vector3.zero, Mathf.InverseLerp(0f, 0.5f, shapeValue)) : Vector3.Lerp(Vector3.zero, iktargetCorrection._info[j]._rmax, Mathf.InverseLerp(0.5f, 1f, shapeValue)));
					vector2 += vector3;
				}
				iktargetCorrection.TargetBone.position = vector;
				iktargetCorrection.TargetBone.transform.localEulerAngles = vector2;
				this._ikBlend[i]._lerpTarget.transform.position = vector;
			}
		}
	}

	// Token: 0x06000D4D RID: 3405 RVA: 0x0005EDD8 File Offset: 0x0005CFD8
	public virtual bool SetIKInfo(int _kind, int _chain, global::AnimeIKCtrl.IKInfo _info, IKEffector _effector, IKConstraintBend _bend)
	{
		Transform transform = null;
		if (_info._target.Length != 0)
		{
			GameObject findObject = this.getFindObject(_info._sex, _info._target);
			transform = ((!(findObject != null)) ? null : findObject.transform);
		}
		_effector.target = transform;
		_effector.positionWeight = ((!(transform != null)) ? 0f : _info._postionWeight);
		_effector.rotationWeight = ((!(transform != null)) ? 0f : _info._rotationWeight);
		this._ikTarget[_kind].Copy(_info._targetCorrection);
		this._ikTarget[_kind].TargetBone = transform;
		this._ikBlend[_kind]._type = global::AnimeIKCtrl.IKBlendInfo.BlendType.Type3;
		this._ikBlend[_kind]._toTarget = transform;
		if (transform == null)
		{
			if (_bend != null)
			{
				_bend.bendGoal = null;
				_bend.weight = 0f;
			}
			return false;
		}
		if (_bend == null || _chain == -1)
		{
			if (_bend != null)
			{
				_bend.bendGoal = null;
				_bend.weight = 0f;
			}
			return true;
		}
		Transform transform2 = null;
		if (_info._chain.Length != 0)
		{
			GameObject gameObject = base.gameObject.transform.FindLoop(_info._chain);
			transform2 = ((!(gameObject != null)) ? null : gameObject.transform);
		}
		_bend.bendGoal = transform2;
		_bend.weight = _info._chainWeight;
		this._ikTarget[_chain].Copy(_info._chainCorrection);
		this._ikTarget[_chain].TargetBone = transform2;
		this._ikBlend[_chain]._type = global::AnimeIKCtrl.IKBlendInfo.BlendType.Type3;
		this._ikBlend[_chain]._toTarget = transform2;
		return true;
	}

	// Token: 0x06000D4E RID: 3406 RVA: 0x0005EF98 File Offset: 0x0005D198
	public virtual bool SetBlendInfo(int _kind, int _chain, global::AnimeIKCtrl.IKInfo _info, global::AnimeIKCtrl.IKInfo _infoOld, IKEffector _effector, IKConstraintBend _bend)
	{
		this._ikTarget[_kind].Init();
		if (_chain != -1)
		{
			this._ikTarget[_chain].Init();
		}
		this._ikBlend[_kind]._effector = _effector;
		this._ikBlend[_kind]._fromTarget = this._ikBlend[_kind]._toTarget;
		this._ikBlend[_kind]._toTarget = null;
		if (_info != null && _info._target.Length != 0)
		{
			GameObject findObject = this.getFindObject(_info._sex, _info._target);
			this._ikBlend[_kind]._toTarget = ((!(findObject != null)) ? null : findObject.transform);
		}
		if (this._ikBlend[_kind]._fromTarget == null && this._ikBlend[_kind]._toTarget != null)
		{
			this._ikBlend[_kind]._type = global::AnimeIKCtrl.IKBlendInfo.BlendType.Type0;
			this._ikBlend[_kind]._fromWeight[0] = 0f;
			this._ikBlend[_kind]._fromWeight[1] = 0f;
			this._ikBlend[_kind]._toWeight[0] = _info._postionWeight;
			this._ikBlend[_kind]._toWeight[1] = _info._rotationWeight;
			_effector.target = this._ikBlend[_kind]._toTarget;
			_effector.positionWeight = 0f;
			_effector.rotationWeight = 0f;
			this._ikBlend[_kind]._targetCorrection[0].Init();
			this._ikBlend[_kind]._targetCorrection[1].Copy(_info._targetCorrection);
			this._ikBlend[_kind]._targetCorrection[1].TargetBone = this._ikBlend[_kind]._toTarget;
			this._ikTarget[_kind].Copy(_info._targetCorrection);
			this._ikTarget[_kind].TargetBone = this._ikBlend[_kind]._toTarget;
		}
		else if (this._ikBlend[_kind]._fromTarget != null && this._ikBlend[_kind]._toTarget != null)
		{
			this._ikBlend[_kind]._type = global::AnimeIKCtrl.IKBlendInfo.BlendType.Type1;
			this._ikBlend[_kind]._fromWeight[0] = _effector.positionWeight;
			this._ikBlend[_kind]._fromWeight[1] = _effector.rotationWeight;
			this._ikBlend[_kind]._toWeight[0] = _info._postionWeight;
			this._ikBlend[_kind]._toWeight[1] = _info._rotationWeight;
			Vector3 position = this._ikBlend[_kind]._fromTarget.position;
			this._ikBlend[_kind]._lerpTarget.transform.position = position;
			Quaternion rotation = this._ikBlend[_kind]._fromTarget.rotation;
			this._ikBlend[_kind]._lerpTarget.transform.rotation = rotation;
			_effector.target = this._ikBlend[_kind]._lerpTarget.transform;
			this._ikTarget[_kind].Init();
			if (_infoOld != null)
			{
				this._ikBlend[_kind]._targetCorrection[0].Copy(_infoOld._targetCorrection);
				this._ikBlend[_kind]._targetCorrection[0].TargetBone = this._ikBlend[_kind]._fromTarget;
				this._ikBlend[_kind]._targetCorrection[1].Copy(_info._targetCorrection);
				this._ikBlend[_kind]._targetCorrection[1].TargetBone = this._ikBlend[_kind]._toTarget;
			}
			else
			{
				this._ikBlend[_kind]._targetCorrection[0].Init();
				this._ikBlend[_kind]._targetCorrection[1].Init();
			}
		}
		else
		{
			if (!(this._ikBlend[_kind]._fromTarget != null) || !(this._ikBlend[_kind]._toTarget == null))
			{
				this._ikBlend[_kind].Reset();
				_effector.target = null;
				_effector.positionWeight = 0f;
				_effector.rotationWeight = 0f;
				if (_bend != null)
				{
					_bend.bendGoal = null;
					_bend.weight = 0f;
				}
				return false;
			}
			this._ikBlend[_kind]._type = global::AnimeIKCtrl.IKBlendInfo.BlendType.Type2;
			this._ikBlend[_kind]._fromWeight[0] = _effector.positionWeight;
			this._ikBlend[_kind]._fromWeight[1] = _effector.rotationWeight;
			this._ikBlend[_kind]._toWeight[0] = 0f;
			this._ikBlend[_kind]._toWeight[1] = 0f;
			if (_infoOld != null)
			{
				this._ikBlend[_kind]._targetCorrection[0].Copy(_infoOld._targetCorrection);
				this._ikBlend[_kind]._targetCorrection[0].TargetBone = this._ikBlend[_kind]._fromTarget;
				this._ikBlend[_kind]._targetCorrection[1].Init();
			}
			else
			{
				this._ikBlend[_kind]._targetCorrection[0].Init();
				this._ikBlend[_kind]._targetCorrection[1].Init();
			}
			this._ikTarget[_kind].Copy(_info._targetCorrection);
			this._ikTarget[_kind].TargetBone = this._ikBlend[_kind]._fromTarget;
		}
		if (_chain == -1 || _bend == null)
		{
			if (_bend != null)
			{
				_bend.bendGoal = null;
				_bend.weight = 0f;
			}
			return true;
		}
		this._ikBlend[_chain]._bend = _bend;
		this._ikBlend[_chain]._fromTarget = this._ikBlend[_chain]._toTarget;
		this._ikBlend[_chain]._toTarget = null;
		if (_info != null && _info._chain.Length != 0)
		{
			GameObject gameObject = base.gameObject.transform.FindLoop(_info._chain);
			this._ikBlend[_chain]._toTarget = ((!(gameObject != null)) ? null : gameObject.transform);
		}
		if (this._ikBlend[_chain]._fromTarget == null && this._ikBlend[_chain]._toTarget != null)
		{
			this._ikBlend[_chain]._type = global::AnimeIKCtrl.IKBlendInfo.BlendType.Type0;
			_bend.bendGoal = this._ikBlend[_chain]._toTarget;
			this._ikBlend[_chain]._fromWeight[0] = 0f;
			this._ikBlend[_chain]._toWeight[0] = _info._chainWeight;
			this._ikTarget[_chain].Copy(_info._chainCorrection);
			this._ikTarget[_chain].TargetBone = this._ikBlend[_chain]._toTarget;
		}
		else if (this._ikBlend[_chain]._fromTarget != null && this._ikBlend[_chain]._toTarget != null)
		{
			this._ikBlend[_chain]._type = global::AnimeIKCtrl.IKBlendInfo.BlendType.Type1;
			_bend.bendGoal = this._ikBlend[_chain]._lerpTarget.transform;
			this._ikBlend[_kind]._lerpTarget.transform.position = this._ikBlend[_chain]._fromTarget.position;
			this._ikBlend[_kind]._lerpTarget.transform.rotation = this._ikBlend[_chain]._fromTarget.rotation;
			this._ikBlend[_chain]._fromWeight[0] = _bend.weight;
			this._ikBlend[_chain]._toWeight[0] = _info._chainWeight;
			this._ikTarget[_chain].Init();
			if (_infoOld != null)
			{
				this._ikBlend[_chain]._targetCorrection[0].Copy(_infoOld._chainCorrection);
				this._ikBlend[_chain]._targetCorrection[0].TargetBone = this._ikBlend[_chain]._fromTarget;
				this._ikBlend[_chain]._targetCorrection[1].Copy(_info._chainCorrection);
				this._ikBlend[_chain]._targetCorrection[1].TargetBone = this._ikBlend[_chain]._toTarget;
			}
			else
			{
				this._ikBlend[_chain]._targetCorrection[0].Init();
				this._ikBlend[_chain]._targetCorrection[1].Init();
			}
		}
		else if (this._ikBlend[_chain]._fromTarget != null && this._ikBlend[_chain]._toTarget == null)
		{
			this._ikBlend[_chain]._type = global::AnimeIKCtrl.IKBlendInfo.BlendType.Type2;
			this._ikBlend[_chain]._fromWeight[0] = _bend.weight;
			this._ikBlend[_chain]._toWeight[0] = 0f;
			this._ikTarget[_chain].Copy(_info._chainCorrection);
			this._ikTarget[_chain].TargetBone = this._ikBlend[_chain]._fromTarget;
		}
		else
		{
			this._ikBlend[_chain].Reset();
			_bend.bendGoal = null;
			_bend.weight = 0f;
		}
		return true;
	}

	// Token: 0x06000D4F RID: 3407 RVA: 0x0005F888 File Offset: 0x0005DA88
	public virtual void SetAnimeIK()
	{
		AnimatorStateInfo currentAnimatorStateInfo = this._animator.GetCurrentAnimatorStateInfo(0);
		foreach (global::AnimeIKCtrl.AnimeIKInfo animeIKInfo in this._ikList)
		{
			if (currentAnimatorStateInfo.IsName(animeIKInfo._animeName))
			{
				this.SetForceIK(animeIKInfo);
				this._ikInfoNext = null;
				this._isIKBlend = false;
				break;
			}
		}
	}

	// Token: 0x06000D50 RID: 3408 RVA: 0x0005F8F4 File Offset: 0x0005DAF4
	public virtual void SetAnimeIK(string _strAnimName)
	{
		foreach (global::AnimeIKCtrl.AnimeIKInfo animeIKInfo in this._ikList)
		{
			if (!(_strAnimName != animeIKInfo._animeName))
			{
				this.SetForceIK(animeIKInfo);
				this._ikInfoNext = null;
				this._isIKBlend = false;
				break;
			}
		}
	}

	// Token: 0x06000D51 RID: 3409 RVA: 0x0005F950 File Offset: 0x0005DB50
	public virtual void SetNextAnimeIK()
	{
		AnimatorStateInfo nextAnimatorStateInfo = this._animator.GetNextAnimatorStateInfo(0);
		foreach (global::AnimeIKCtrl.AnimeIKInfo animeIKInfo in this._ikList)
		{
			if (nextAnimatorStateInfo.IsName(animeIKInfo._animeName))
			{
				this.SetBlendIK(animeIKInfo, true);
				break;
			}
		}
	}

	// Token: 0x06000D52 RID: 3410 RVA: 0x0005F9B0 File Offset: 0x0005DBB0
	public virtual void UpdateAnimeIK()
	{
		if (this._animator.runtimeAnimatorController == null)
		{
			return;
		}
		this._animeTransInfo = this._animator.GetAnimatorTransitionInfo(0);
		if (!this.IsIKBlend && this._animeTransInfo.normalizedTime != 0f)
		{
			this.SetNextAnimeIK();
		}
	}

	// Token: 0x06000D53 RID: 3411 RVA: 0x0005FA0C File Offset: 0x0005DC0C
	public virtual bool LoadExcelData(string _strAssetPath, string _strResourcePath, bool _bSetIK = true, bool _direct = false)
	{
		global::ExcelData excelData = this.LoadFindExcelData(_strAssetPath, _strResourcePath, _direct);
		if (excelData == null)
		{
			return false;
		}
		List<string> cell = excelData.GetCell(2);
		List<string> row = excelData.GetRow(1);
		List<global::ExcelData.Param> list = excelData.Get(new global::ExcelData.Specify(1, 4), new global::ExcelData.Specify(cell.Count, row.Count));
		int count = list.Count;
		if (count == 0 || count < 102)
		{
			global::Debug.LogWarning("excel : [" + _strResourcePath + "]は最低でも102行は必要");
			return false;
		}
		int count2 = list[0].list.Count;
		if (count2 == 0)
		{
			global::Debug.LogWarning("excel : [" + _strResourcePath + "]は読み込む列がない");
			return false;
		}
		this._ikList = new global::AnimeIKCtrl.AnimeIKInfo[count2];
		for (int i = 0; i < count2; i++)
		{
			this._ikList[i] = new global::AnimeIKCtrl.AnimeIKInfo();
			int num = 0;
			this._ikList[i]._animeName = list[num++].list[i];
			global::AnimeIKCtrl.IKInfo[] array = new global::AnimeIKCtrl.IKInfo[]
			{
				this._ikList[i]._bodyIK,
				this._ikList[i]._leftArmIK,
				this._ikList[i]._rightArmIK,
				this._ikList[i]._LeftLegIK,
				this._ikList[i]._rightLegIK
			};
			for (int j = 0; j < 5; j++)
			{
				array[j]._sex = int.Parse(list[num++].list[i]);
				array[j]._target = list[num++].list[i];
				array[j]._postionWeight = float.Parse(list[num++].list[i]);
				array[j]._rotationWeight = float.Parse(list[num++].list[i]);
				for (int k = 0; k < 7; k++)
				{
					global::AnimeIKCtrl.IKTargetCorrectionInfo iktargetCorrectionInfo = new global::AnimeIKCtrl.IKTargetCorrectionInfo();
					string text = list[num++].list[i];
					if (text == string.Empty)
					{
						num += 12;
					}
					else
					{
						iktargetCorrectionInfo._editNo = int.Parse(text);
						iktargetCorrectionInfo._tmin = new Vector3(float.Parse(list[num++].list[i]), float.Parse(list[num++].list[i]), float.Parse(list[num++].list[i]));
						iktargetCorrectionInfo._tmax = new Vector3(float.Parse(list[num++].list[i]), float.Parse(list[num++].list[i]), float.Parse(list[num++].list[i]));
						iktargetCorrectionInfo._rmin = new Vector3(float.Parse(list[num++].list[i]), float.Parse(list[num++].list[i]), float.Parse(list[num++].list[i]));
						iktargetCorrectionInfo._rmax = new Vector3(float.Parse(list[num++].list[i]), float.Parse(list[num++].list[i]), float.Parse(list[num++].list[i]));
						array[j]._targetCorrection._info.Add(iktargetCorrectionInfo);
					}
				}
				array[j]._chain = list[num++].list[i];
				array[j]._chainWeight = float.Parse(list[num++].list[i]);
				for (int l = 0; l < 7; l++)
				{
					global::AnimeIKCtrl.IKTargetCorrectionInfo iktargetCorrectionInfo2 = new global::AnimeIKCtrl.IKTargetCorrectionInfo();
					string text2 = list[num++].list[i];
					if (text2 == string.Empty)
					{
						num += 12;
					}
					else
					{
						iktargetCorrectionInfo2._editNo = int.Parse(text2);
						iktargetCorrectionInfo2._tmin = new Vector3(float.Parse(list[num++].list[i]), float.Parse(list[num++].list[i]), float.Parse(list[num++].list[i]));
						iktargetCorrectionInfo2._tmax = new Vector3(float.Parse(list[num++].list[i]), float.Parse(list[num++].list[i]), float.Parse(list[num++].list[i]));
						iktargetCorrectionInfo2._rmin = new Vector3(float.Parse(list[num++].list[i]), float.Parse(list[num++].list[i]), float.Parse(list[num++].list[i]));
						iktargetCorrectionInfo2._rmax = new Vector3(float.Parse(list[num++].list[i]), float.Parse(list[num++].list[i]), float.Parse(list[num++].list[i]));
						array[j]._chainCorrection._info.Add(iktargetCorrectionInfo2);
					}
				}
			}
			this._ikList[i]._blendTime = float.Parse(list[num++].list[i]);
		}
		if (_bSetIK)
		{
			this.SetAnimeIK();
		}
		return true;
	}

	// Token: 0x06000D54 RID: 3412 RVA: 0x000600D4 File Offset: 0x0005E2D4
	public virtual global::ExcelData LoadFindExcelData(string _strAssetPath, string _strResourcePath, bool _direct)
	{
		if (_direct)
		{
			return this.LoadFindExcelDataDirect(_strAssetPath, _strResourcePath);
		}
		List<string> assetBundleNameListFromPath = global::CommonLib.GetAssetBundleNameListFromPath(_strAssetPath, false);
		for (int i = 0; i < assetBundleNameListFromPath.Count; i++)
		{
			string[] allAssetName = global::AssetBundleCheck.GetAllAssetName(assetBundleNameListFromPath[i], false);
			bool flag = false;
			for (int j = 0; j < allAssetName.Length; j++)
			{
				if (allAssetName[j].Compare(_strResourcePath, true))
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				global::Debug.LogWarning(string.Concat(new string[]
				{
					"[",
					assetBundleNameListFromPath[i],
					"][",
					_strResourcePath,
					"]は見つかりません"
				}));
			}
			else
			{
				global::ExcelData excelData = this.LoadFindExcelDataDirect(assetBundleNameListFromPath[i], _strResourcePath);
				if (excelData != null)
				{
					return excelData;
				}
			}
		}
		return null;
	}

	// Token: 0x06000D55 RID: 3413 RVA: 0x000601B8 File Offset: 0x0005E3B8
	public virtual global::ExcelData LoadFindExcelDataDirect(string _strAssetPath, string _strResourcePath)
	{
		global::ExcelData excelData = global::CommonLib.LoadAsset<global::ExcelData>(_strAssetPath, _strResourcePath, false, string.Empty);
		global::AssetBundleManager.UnloadAssetBundle(_strAssetPath, true, null);
		if (excelData != null)
		{
			return excelData;
		}
		return null;
	}

	// Token: 0x06000D56 RID: 3414 RVA: 0x000601EC File Offset: 0x0005E3EC
	public virtual GameObject getFindObject(int _nSex, string _strTarget)
	{
		GameObject result = null;
		if (_nSex == 0)
		{
			result = base.gameObject.transform.FindLoop(_strTarget);
		}
		else if (_nSex == 1)
		{
			result = ((!(this._partnerObj != null)) ? null : this._partnerObj.transform.FindLoop(_strTarget));
		}
		else if (_nSex == 2)
		{
			result = ((!(this._itemObj != null)) ? null : this._itemObj.transform.FindLoop(_strTarget));
		}
		else if (_nSex == 3)
		{
			result = ((!(this._partnerObj1 != null)) ? null : this._partnerObj1.transform.FindLoop(_strTarget));
		}
		return result;
	}

	// Token: 0x06000D57 RID: 3415 RVA: 0x000602B4 File Offset: 0x0005E4B4
	public virtual float GetShapeValue(int _idx)
	{
		int num = _idx / 100;
		float result = 0f;
		switch (num)
		{
		case 0:
			if (this._editInfo != null)
			{
				result = this._editInfo.GetShapeBodyValue(_idx);
			}
			else if (this._editRate != null && global::MathfEx.RangeEqualOff(0, _idx, this._editRate.Length))
			{
				result = this._editRate[_idx];
			}
			break;
		case 1:
			if (this._editInfoAnother != null)
			{
				result = this._editInfoAnother.GetShapeBodyValue(_idx % 100);
			}
			break;
		case 3:
			if (this._editInfoAnother1 != null)
			{
				result = this._editInfoAnother1.GetShapeBodyValue(_idx % 100);
			}
			break;
		}
		return result;
	}

	// Token: 0x04000E35 RID: 3637
	[SerializeField]
	protected Animator _animator;

	// Token: 0x04000E36 RID: 3638
	[SerializeField]
	protected FullBodyBipedIK _ik;

	// Token: 0x04000E37 RID: 3639
	[SerializeField]
	protected global::AnimeIKCtrl.AnimeIKInfo[] _ikList;

	// Token: 0x04000E38 RID: 3640
	protected global::AnimeIKCtrl.IKBlendInfo[] _ikBlend;

	// Token: 0x04000E39 RID: 3641
	protected global::AnimeIKCtrl.IKTargetCorrection[] _ikTarget;

	// Token: 0x04000E3A RID: 3642
	protected AnimatorTransitionInfo _animeTransInfo;

	// Token: 0x04000E3B RID: 3643
	protected global::AnimeIKCtrl.AnimeIKInfo.BlendType _blendType;

	// Token: 0x04000E3C RID: 3644
	protected float _blendTime = 0.5f;

	// Token: 0x04000E3D RID: 3645
	protected float _time;

	// Token: 0x04000E3E RID: 3646
	protected bool _isIKBlend;

	// Token: 0x04000E3F RID: 3647
	protected global::AnimeIKCtrl.AnimeIKInfo _ikInfoOld;

	// Token: 0x04000E40 RID: 3648
	protected global::AnimeIKCtrl.AnimeIKInfo _ikInfoNext;

	// Token: 0x04000E41 RID: 3649
	public bool bDrawGUI = true;

	// Token: 0x02000249 RID: 585
	[Serializable]
	public class IKTargetCorrectionInfo
	{
		// Token: 0x170001B7 RID: 439
		// (get) Token: 0x06000D59 RID: 3417 RVA: 0x000603A8 File Offset: 0x0005E5A8
		// (set) Token: 0x06000D5A RID: 3418 RVA: 0x000603B0 File Offset: 0x0005E5B0
		public Transform TargetBone { get; set; }

		// Token: 0x06000D5B RID: 3419 RVA: 0x000603BC File Offset: 0x0005E5BC
		public virtual void Init()
		{
			this._editNo = 0;
			this._tmin = Vector3.zero;
			this._tmax = Vector3.zero;
			this._rmin = Vector3.zero;
			this._rmax = Vector3.zero;
			this.TargetBone = null;
		}

		// Token: 0x06000D5C RID: 3420 RVA: 0x000603F8 File Offset: 0x0005E5F8
		public virtual void Copy(global::AnimeIKCtrl.IKTargetCorrectionInfo _in)
		{
			this._editNo = _in._editNo;
			this._tmin = _in._tmin;
			this._tmax = _in._tmax;
			this._rmin = _in._rmin;
			this._rmax = _in._rmax;
			this.TargetBone = _in.TargetBone;
		}

		// Token: 0x04000E4A RID: 3658
		public int _editNo;

		// Token: 0x04000E4B RID: 3659
		public Vector3 _tmin = Vector3.zero;

		// Token: 0x04000E4C RID: 3660
		public Vector3 _tmax = Vector3.zero;

		// Token: 0x04000E4D RID: 3661
		public Vector3 _rmin = Vector3.zero;

		// Token: 0x04000E4E RID: 3662
		public Vector3 _rmax = Vector3.zero;
	}

	// Token: 0x0200024A RID: 586
	[Serializable]
	public class IKTargetCorrection
	{
		// Token: 0x170001B8 RID: 440
		// (get) Token: 0x06000D5E RID: 3422 RVA: 0x00060464 File Offset: 0x0005E664
		// (set) Token: 0x06000D5F RID: 3423 RVA: 0x0006046C File Offset: 0x0005E66C
		public Transform TargetBone { get; set; }

		// Token: 0x06000D60 RID: 3424 RVA: 0x00060478 File Offset: 0x0005E678
		public virtual void Init()
		{
			this.TargetBone = null;
			this._info = new List<global::AnimeIKCtrl.IKTargetCorrectionInfo>();
		}

		// Token: 0x06000D61 RID: 3425 RVA: 0x0006048C File Offset: 0x0005E68C
		public virtual void Copy(global::AnimeIKCtrl.IKTargetCorrection _in)
		{
			this._info = new List<global::AnimeIKCtrl.IKTargetCorrectionInfo>(_in._info);
			this.TargetBone = _in.TargetBone;
		}

		// Token: 0x04000E50 RID: 3664
		public List<global::AnimeIKCtrl.IKTargetCorrectionInfo> _info = new List<global::AnimeIKCtrl.IKTargetCorrectionInfo>();
	}

	// Token: 0x0200024B RID: 587
	[Serializable]
	public class IKInfo
	{
		// Token: 0x04000E52 RID: 3666
		public int _sex;

		// Token: 0x04000E53 RID: 3667
		public string _target;

		// Token: 0x04000E54 RID: 3668
		public float _postionWeight;

		// Token: 0x04000E55 RID: 3669
		public float _rotationWeight;

		// Token: 0x04000E56 RID: 3670
		public global::AnimeIKCtrl.IKTargetCorrection _targetCorrection = new global::AnimeIKCtrl.IKTargetCorrection();

		// Token: 0x04000E57 RID: 3671
		public string _chain;

		// Token: 0x04000E58 RID: 3672
		public float _chainWeight;

		// Token: 0x04000E59 RID: 3673
		public global::AnimeIKCtrl.IKTargetCorrection _chainCorrection = new global::AnimeIKCtrl.IKTargetCorrection();
	}

	// Token: 0x0200024C RID: 588
	[Serializable]
	public class AnimeIKInfo
	{
		// Token: 0x04000E5A RID: 3674
		public string _animeName;

		// Token: 0x04000E5B RID: 3675
		public global::AnimeIKCtrl.IKInfo _bodyIK = new global::AnimeIKCtrl.IKInfo();

		// Token: 0x04000E5C RID: 3676
		public global::AnimeIKCtrl.IKInfo _leftArmIK = new global::AnimeIKCtrl.IKInfo();

		// Token: 0x04000E5D RID: 3677
		public global::AnimeIKCtrl.IKInfo _rightArmIK = new global::AnimeIKCtrl.IKInfo();

		// Token: 0x04000E5E RID: 3678
		public global::AnimeIKCtrl.IKInfo _LeftLegIK = new global::AnimeIKCtrl.IKInfo();

		// Token: 0x04000E5F RID: 3679
		public global::AnimeIKCtrl.IKInfo _rightLegIK = new global::AnimeIKCtrl.IKInfo();

		// Token: 0x04000E60 RID: 3680
		public float _blendTime = 0.5f;

		// Token: 0x0200024D RID: 589
		public enum BlendType
		{
			// Token: 0x04000E62 RID: 3682
			Type0,
			// Token: 0x04000E63 RID: 3683
			Type1
		}
	}

	// Token: 0x0200024E RID: 590
	public class IKBlendInfo
	{
		// Token: 0x06000D64 RID: 3428 RVA: 0x00060524 File Offset: 0x0005E724
		public IKBlendInfo()
		{
			this._lerpTarget.name = "IKBlendLerpTarget";
			this._targetCorrection[0] = new global::AnimeIKCtrl.IKTargetCorrection();
			this._targetCorrection[1] = new global::AnimeIKCtrl.IKTargetCorrection();
		}

		// Token: 0x06000D65 RID: 3429 RVA: 0x00060580 File Offset: 0x0005E780
		public virtual void Reset()
		{
			this._fromTarget = null;
			this._toTarget = null;
			this._type = global::AnimeIKCtrl.IKBlendInfo.BlendType.Type3;
		}

		// Token: 0x04000E64 RID: 3684
		public Transform _fromTarget;

		// Token: 0x04000E65 RID: 3685
		public Transform _toTarget;

		// Token: 0x04000E66 RID: 3686
		public float[] _fromWeight;

		// Token: 0x04000E67 RID: 3687
		public float[] _toWeight;

		// Token: 0x04000E68 RID: 3688
		public global::AnimeIKCtrl.IKBlendInfo.BlendType _type = global::AnimeIKCtrl.IKBlendInfo.BlendType.Type3;

		// Token: 0x04000E69 RID: 3689
		public GameObject _lerpTarget = new GameObject();

		// Token: 0x04000E6A RID: 3690
		public IKEffector _effector;

		// Token: 0x04000E6B RID: 3691
		public IKConstraintBend _bend;

		// Token: 0x04000E6C RID: 3692
		public global::AnimeIKCtrl.IKTargetCorrection[] _targetCorrection = new global::AnimeIKCtrl.IKTargetCorrection[2];

		// Token: 0x0200024F RID: 591
		public enum BlendType
		{
			// Token: 0x04000E6E RID: 3694
			Type0,
			// Token: 0x04000E6F RID: 3695
			Type1,
			// Token: 0x04000E70 RID: 3696
			Type2,
			// Token: 0x04000E71 RID: 3697
			Type3
		}
	}

	// Token: 0x02000250 RID: 592
	private enum IKBlendKind
	{
		// Token: 0x04000E73 RID: 3699
		Kind0,
		// Token: 0x04000E74 RID: 3700
		Kind1,
		// Token: 0x04000E75 RID: 3701
		Kind2,
		// Token: 0x04000E76 RID: 3702
		Kind3,
		// Token: 0x04000E77 RID: 3703
		Kind4,
		// Token: 0x04000E78 RID: 3704
		Kind5,
		// Token: 0x04000E79 RID: 3705
		Kind6,
		// Token: 0x04000E7A RID: 3706
		Kind7,
		// Token: 0x04000E7B RID: 3707
		Kind8,
		// Token: 0x04000E7C RID: 3708
		Num
	}
}
